//#include <stdio.h>
//#include <stdlib.h>


//int rand = 0;
//
//int main()
//{
//	printf("%d\n", rand);
//	return 0;
//}

// 命名空间域
//namespace wh
//{
//	int rand = 0;
//}

//命令冲突
//我们和库，我们之间
//用变量/函数....
//编译默认查找
//a、当前局部域
//b、全局域
//c、到展开的命名空间中查找

//int main()
//{
//	printf("%d\n", ::rand);
//	printf("%d\n", wh::rand);
//	return 0;
//}

//int a = 0;
//int main()
//{
//	int a = 1;
//	printf("%d\n", a);
//	printf("%d\n", ::a);//::域作用限定符,左边不给东西默认访问的是全局的
//	return 0;
//}

// 局部域 - 会影响生命周期
// 全局域 - 会影响生命周期
// 命名空间域 - 不会影响生命周期，还是全局的，只是名字隔离起来了
// 不同域可以定义同名变量/函数/类型

//namespace wh
//{
//	int Add(int x, int y)
//	{
//		return x + y;
//	}
//
//	struct node
//	{
//
//	};
//}
//namespace Aurora
//{
//	int Add(int x, int y)
//	{
//		return 10*(x + y);
//	}
//
//	struct node
//	{
//
//	};
//}
//using  Aurora::Add;
//int main()
//{
//	printf("%d\n", Add(1, 2));
//	Aurora::node; //没展开，得指定
//	return 0;
//}

//namespace Aurora
//{
//	namespace wh
//	{
//		int Add(int x, int y)
//		{
//			return x + y;
//		}
//
//		struct node
//		{
//
//		};
//	}
//}
//
//int main()
//{
//	printf("%d\n", Aurora::wh::Add(1, 2));
//	Aurora::wh::node;
//	return 0;
//}

// vc6.0
// #include <iostream.h>

//#include <iostream>
//using namespace std;
//
////全缺省参数
//void func1(int x = 10, int y = 20, int z = 30)
//{
//	printf("x = :%d\n", x);
//	printf("y = :%d\n", y);
//	printf("z = :%d\n", z);
//}
//
////半缺省参数
//void func2(int x, int y = 20, int z = 30)
//{
//	printf("x = :%d\n", x);
//	printf("y = :%d\n", y);
//	printf("z = :%d\n", z);
//}
//
//int main()
//{
//	func1(1, 2, 3);
//	func1(1, 2);
//	func1(1);
//	func1();
//	printf("-------------------\n");
//	func2(1, 2, 3);
//	func2(1, 2);
//	func2(1);
//
//	return 0;
//}
//#include "Stack.h"
//
//int main()
//{
//	//struct Stack st;
//
//	//StackInit(&st,10);
//
//	f('a', 1);
//	f(10,'b');
//	f(10,10);
//	
//	return 0;
//}

#include <iostream>

//int main()
//{
//	int a = 0;
//	//引用:b是a的别名
//	int& b = a;
//	int& c = a;
//	//给别名取别名
//	int& d = b;
//
//	++d;
//
//	std::cout << &a << std::endl;
//	std::cout << &b << std::endl;
//	std::cout << &c << std::endl;
//	std::cout << &d << std::endl;
//
//	return 0;
//}


//int main()
//{
//	double d = 12.34;
//	int a = d;
//	int& b = d;//类型转换中间会产生临时变量，所有这是权限放大
//	const int& c = d;
//
//	int x = 0, y = 1;
//	int& r1 = x + y;//表达式+也会产生临时变量
//	const int& r2 = x + y;
//
//
//	return 0;
//}

//int main()
//{
//	int a = 0;
//	int& b = a; // 语法上不开空间
//
//	int* p = &a;// 语法上要开空间
//
//	int* ptr = NULL;
//	int& r = *ptr;//这里不报错，只是把ptr地址存起来
//	//std::cout << r << std::endl;//这里报错，取值了
//
//	std::cout << sizeof(b) << std::endl;
//	std::cout << sizeof(int&) << std::endl;
//
//	return 0;
//}

//void swap(int& a, int& b)
//{
//	//...
//}
// 频繁调用的小函数
// C->宏
//#define ADD(a,b) ((a)+(b))
// 为什么不能加分号
// 为什么要加里面的括号
// 为什么要加外面的括号
//int main()
//{
//	
//	return 0;
//}

//Debug版本下默认不展开 -> 方便调试
//inline int Add(int a, int b)
//{
//	int ret = a + b;
//	return a + b;
//}
//
//int main()
//{
//	int c = Add(1, 2);
//	std::cout << c << std::endl;
//	return 0;
//}

int TestAuto()
{
	return 10;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();
	std::cout << typeid(b).name() << std::endl;
	std::cout << typeid(c).name() << std::endl;
	std::cout << typeid(d).name() << std::endl;

	int x = 10;

	auto a1 = x;
	auto a2 = &x;

	//指定必须是指针
	auto* b = &x; 

	//引用
	auto& c = x;	
}
